GraphQL Föderáció: Schema Stitching - Részletes útmutató

A modern alkalmazásfejlesztés folyamatosan fejlődő világában a skálázható és karbantartható architektúrák iránti igény kiemelkedővé vált. A mikroszolgáltatások, eredendő modularitásukkal és független telepíthetőségükkel, népszerű megoldásként jelentek meg. Számos mikroszolgáltatás kezelése azonban bonyodalmakat okozhat, különösen, ha egységes API-t kell biztosítani a kliensalkalmazások számára. Itt lép a képbe a GraphQL Föderáció, és különösen a Schema Stitching.

Mi az a GraphQL Föderáció?

A GraphQL Föderáció egy hatékony architektúra, amely lehetővé teszi egyetlen, egységes GraphQL API létrehozását több mögöttes GraphQL szolgáltatásból (gyakran mikroszolgáltatásokat képviselve). Lehetővé teszi a fejlesztők számára, hogy több különböző szolgáltatáson keresztül kérdezzenek le adatokat, mintha azok egyetlen gráfot alkotnának, egyszerűsítve a kliensélményt és csökkentve a komplex vezénylési logika szükségességét a kliensoldalon.

A GraphQL Föderációnak két fő megközelítése van:

• Schema Stitching: Ez több GraphQL séma egyetlen, egységes sémává való egyesítését jelenti az átjáró (gateway) rétegen. Ez egy korábbi megközelítés, amely könyvtárakra támaszkodik a sémák kombinálásának és a lekérdezések delegálásának kezelésére.
• Apollo Föderáció: Ez egy újabb és robusztusabb megközelítés, amely egy deklaratív séma nyelvet és egy dedikált lekérdezés-tervezőt használ a föderációs folyamat kezelésére. Fejlett funkciókat kínál, mint például a típus kiterjesztések, kulcs direktívák és az elosztott nyomkövetés.

Ez a cikk a Schema Stitchingre fókuszál, feltárva annak koncepcióit, előnyeit, korlátait és gyakorlati megvalósítását.

A Schema Stitching megértése

A Schema Stitching több GraphQL séma egyetlen, koherens sémává történő összefűzésének folyamata. Ez az egységes séma egy homlokzatként működik, elrejtve a mögöttes szolgáltatások bonyolultságát a kliens elől. Amikor egy kliens kérést küld az összefűzött sémához, az átjáró intelligensen továbbítja a kérést a megfelelő mögöttes szolgáltatás(ok)hoz, lekéri az adatokat, és az eredményeket egyesíti, mielőtt visszaküldené azokat a kliensnek.

Gondoljon rá úgy, mint: van több étterme (szolgáltatása), amelyek mind különböző konyhákra specializálódtak. A Schema Stitching olyan, mint egy univerzális étlap, amely az összes étterem összes fogását egyesíti. Amikor egy vendég (kliens) rendel az univerzális étlapról, a rendelést intelligensen a megfelelő éttermi konyhákba irányítják, az ételt elkészítik, majd egyetlen szállítmányként egyesítik a vendég számára.

A Schema Stitching kulcsfogalmai

• Távoli sémák (Remote Schemas): Ezek az egyes mögöttes szolgáltatások egyedi GraphQL sémái. Minden szolgáltatás a saját sémáját teszi közzé, amely meghatározza az általa biztosított adatokat és műveleteket.
• Átjáró (Gateway): Az átjáró a központi komponens, amely felelős a távoli sémák összefűzéséért és az egységes séma kliens felé történő közzétételéért. Fogadja a kliens kéréseket, továbbítja azokat a megfelelő szolgáltatásokhoz, és egyesíti az eredményeket.
• Sémaegyesítés (Schema Merging): Ez a folyamat, amelynek során a távoli sémákat egyetlen sémává kombinálják. Ez gyakran magában foglalja a típusok és mezők átnevezését a konfliktusok elkerülése érdekében, valamint a különböző sémák típusai közötti kapcsolatok meghatározását.
• Lekérdezés delegálása (Query Delegation): Amikor egy kliens kérést küld az összefűzött sémához, az átjárónak delegálnia kell a kérést a megfelelő mögöttes szolgáltatás(ok)hoz az adatok lekéréséhez. Ez magában foglalja a kliens lekérdezésének lefordítását egy olyan lekérdezésre, amelyet a távoli szolgáltatás megért.
• Eredmény-összesítés (Result Aggregation): Miután az átjáró lekérte az adatokat a mögöttes szolgáltatásokból, az eredményeket egyetlen válaszba kell összesítenie, amelyet vissza lehet küldeni a kliensnek. Ez gyakran magában foglalja az adatok átalakítását, hogy megfeleljenek az összefűzött séma szerkezetének.

A Schema Stitching előnyei

A Schema Stitching számos meggyőző előnyt kínál a mikroszolgáltatási architektúrát alkalmazó szervezetek számára:

• Egységes API: Egyetlen, következetes API-t biztosít a kliensek számára, egyszerűsítve az adathozzáférést és csökkentve annak szükségességét, hogy a kliensek közvetlenül több szolgáltatással lépjenek kapcsolatba. Ez tisztább és intuitívabb fejlesztői élményt eredményez.
• Csökkentett kliensoldali bonyolultság: A klienseknek csak az egységes sémával kell kommunikálniuk, ami megvédi őket a mögöttes mikroszolgáltatási architektúra bonyolultságától. Ez egyszerűsíti a kliensoldali fejlesztést és csökkenti a kliensen szükséges kód mennyiségét.
• Növelt skálázhatóság: Lehetővé teszi az egyes szolgáltatások egymástól független skálázását a specifikus igényeik alapján. Ez javítja a rendszer általános skálázhatóságát és rugalmasságát. Például egy nagy terhelésű felhasználói szolgáltatás skálázható anélkül, hogy ez hatással lenne más szolgáltatásokra, mint például a termékkatalógusra.
• Jobb karbantarthatóság: Elősegíti a modularitást és a felelősségi körök szétválasztását, megkönnyítve az egyes szolgáltatások karbantartását és fejlesztését. Egy szolgáltatáson végrehajtott változtatások kevésbé valószínű, hogy hatással lesznek más szolgáltatásokra.
• Fokozatos bevezetés: Növekményesen is megvalósítható, lehetővé téve a monolitikus architektúráról a mikroszolgáltatási architektúrára való fokozatos áttérést. Kezdheti a meglévő API-k összefűzésével, majd fokozatosan bonthatja le a monolitot kisebb szolgáltatásokra.

A Schema Stitching korlátai

Bár a Schema Stitching számos előnnyel jár, fontos tisztában lenni a korlátaival:

• Bonyolultság: A schema stitching megvalósítása és kezelése összetett lehet, különösen nagy és komplex rendszerekben. A gondos tervezés elengedhetetlen.
• Teljesítménytöbblet: Az átjáró némi teljesítménytöbbletet okoz a további indirekciós réteg, valamint a lekérdezések delegálásának és az eredmények összesítésének szükségessége miatt. A gondos optimalizálás kulcsfontosságú e többlet minimalizálásához.
• Sémakonfliktusok: Konfliktusok merülhetnek fel a különböző szolgáltatások sémáinak egyesítésekor, különösen, ha azonos típus- vagy mezőneveket használnak. Ez gondos sématervezést és potenciálisan a típusok és mezők átnevezését igényli.
• Korlátozott haladó funkciók: Az Apollo Föderációhoz képest a Schema Stitchingből hiányoznak bizonyos haladó funkciók, mint például a típus kiterjesztések és a kulcs direktívák, ami megnehezítheti a különböző sémák közötti típuskapcsolatok kezelését.
• Eszközök fejlettsége: A Schema Stitching körüli eszközök és ökoszisztéma nem olyan kiforrott, mint az Apollo Föderáció esetében. Ez megnehezítheti a hibakeresést és a problémamegoldást.

A Schema Stitching gyakorlati megvalósítása

Nézzünk meg egy egyszerűsített példát a Schema Stitching megvalósítására Node.js és a graphql-tools könyvtár (egy népszerű választás a schema stitchinghez) segítségével. Ez a példa két mikroszolgáltatást tartalmaz: egy Felhasználói Szolgáltatást (User Service) és egy Termék Szolgáltatást (Product Service).

1. A távoli sémák definiálása

Először definiálja a GraphQL sémákat mindkét távoli szolgáltatáshoz.

Felhasználói Szolgáltatás (user-service.js):

            
const { buildSchema } = require('graphql');

const userSchema = buildSchema(`
  type User {
    id: ID!
    name: String
    email: String
  }

  type Query {
    user(id: ID!): User
  }
`);

const users = [
  { id: '1', name: 'Alice Smith', email: 'alice@example.com' },
  { id: '2', name: 'Bob Johnson', email: 'bob@example.com' },
];

const userRoot = {
  user: (args) => users.find(user => user.id === args.id),
};

module.exports = {
  schema: userSchema,
  rootValue: userRoot,
};

            

              
                Copy
              
            
          

Termék Szolgáltatás (product-service.js):

            
const { buildSchema } = require('graphql');

const productSchema = buildSchema(`
  type Product {
    id: ID!
    name: String
    price: Float
    userId: ID!  # Idegen kulcs a Felhasználói Szolgáltatáshoz
  }

  type Query {
    product(id: ID!): Product
  }
`);

const products = [
  { id: '101', name: 'Laptop', price: 1200, userId: '1' },
  { id: '102', name: 'Smartphone', price: 800, userId: '2' },
];

const productRoot = {
  product: (args) => products.find(product => product.id === args.id),
};

module.exports = {
  schema: productSchema,
  rootValue: productRoot,
};

            

              
                Copy
              
            
          

2. Az átjáró szolgáltatás létrehozása

Most hozza létre az átjáró szolgáltatást, amely összefűzi a két sémát.

Átjáró Szolgáltatás (gateway.js):

            
const { stitchSchemas } = require('@graphql-tools/stitch');
const { makeRemoteExecutableSchema } = require('@graphql-tools/wrap');
const { graphqlHTTP } = require('express-graphql');
const express = require('express');
const { introspectSchema } = require('@graphql-tools/wrap');
const { printSchema } = require('graphql');
const fetch = require('node-fetch');

async function createRemoteSchema(uri) {
  const fetcher = async (params) => {
    const response = await fetch(uri, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(params),
    });
    return response.json();
  };

  const schema = await introspectSchema(fetcher);
  return makeRemoteExecutableSchema({
    schema,
    fetcher,
  });
}

async function main() {
  const userSchema = await createRemoteSchema('http://localhost:4001/graphql');
  const productSchema = await createRemoteSchema('http://localhost:4002/graphql');

  const stitchedSchema = stitchSchemas({
    subschemas: [
      { schema: userSchema },
      { schema: productSchema },
    ],
    typeDefs: `
      extend type Product {
        user: User
      }
    `,
    resolvers: {
      Product: {
        user: {
          selectionSet: `{ userId }`,
          resolve(product, args, context, info) {
            return info.mergeInfo.delegateToSchema({
              schema: userSchema,
              operation: 'query',
              fieldName: 'user',
              args: {
                id: product.userId,
              },
              context,
              info,
            });
          },
        },
      },
    },
  });

  const app = express();
  app.use('/graphql', graphqlHTTP({
    schema: stitchedSchema,
    graphiql: true,
  }));

  app.listen(4000, () => console.log('Átjáró szerver fut a http://localhost:4000/graphql címen'));
}

main().catch(console.error);

            

              
                Copy
              
            
          

3. A szolgáltatások futtatása

A Felhasználói Szolgáltatást és a Termék Szolgáltatást különböző portokon kell futtatnia. Például:

Felhasználói Szolgáltatás (4001-es port):

            
const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { schema, rootValue } = require('./user-service');

const app = express();
app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: rootValue,
  graphiql: true,
}));

app.listen(4001, () => console.log('Felhasználói szolgáltatás fut a http://localhost:4001/graphql címen'));

            

              
                Copy
              
            
          

Termék Szolgáltatás (4002-es port):

            
const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { schema, rootValue } = require('./product-service');

const app = express();
app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: rootValue,
  graphiql: true,
}));

app.listen(4002, () => console.log('Termék szolgáltatás fut a http://localhost:4002/graphql címen'));

            

              
                Copy
              
            
          

4. Az összefűzött séma lekérdezése

Most már lekérdezheti az összefűzött sémát az átjárón keresztül (amely a 4000-es porton fut). Egy ehhez hasonló lekérdezést futtathat:

            
query {
  product(id: "101") {
    id
    name
    price
    user {
      id
      name
      email
    }
  }
}

            

              
                Copy
              
            
          

Ez a lekérdezés lekéri a "101"-es azonosítójú terméket, és lekéri a hozzá tartozó felhasználót is a Felhasználói Szolgáltatásból, bemutatva, hogy a Schema Stitching hogyan teszi lehetővé az adatok lekérdezését több szolgáltatásból egyetlen kérésben.

Haladó Schema Stitching technikák

Az alapvető példán túl, íme néhány haladó technika, amelyekkel javíthatja a Schema Stitching implementációját:

• Séma delegálás: Ez lehetővé teszi, hogy egy lekérdezés részeit különböző szolgáltatásoknak delegálja a kért adatok alapján. Például delegálhatja a `User` típus feloldását a Felhasználói Szolgáltatásnak, és a `Product` típus feloldását a Termék Szolgáltatásnak.
• Séma átalakítás: Ez magában foglalja egy távoli szolgáltatás sémájának módosítását, mielőtt azt az egységes sémába fűznék. Ez hasznos lehet típusok és mezők átnevezésére, új mezők hozzáadására vagy meglévő mezők eltávolítására.
• Egyéni resolverek: Definiálhat egyéni resolvereket az átjáróban, hogy kezelje a komplex adatátalakításokat, vagy hogy több szolgáltatásból kérjen le adatokat és azokat egyetlen eredménybe kombinálja.
• Kontextus megosztása: Gyakran szükséges kontextusinformációkat, például hitelesítési tokeneket vagy felhasználói azonosítókat megosztani az átjáró és a távoli szolgáltatások között. Ezt a kontextusinformációk átadásával lehet elérni a lekérdezés delegálási folyamat részeként.
• Hibakezelés: Implementáljon robusztus hibakezelést a távoli szolgáltatásokban előforduló hibák elegáns kezelésére. Ez magában foglalhatja a hibák naplózását, felhasználóbarát hibaüzenetek visszaküldését vagy a sikertelen kérések újrapróbálását.

Választás a Schema Stitching és az Apollo Föderáció között

Bár a Schema Stitching egy életképes opció a GraphQL Föderációhoz, az Apollo Föderáció vált a népszerűbb választássá a fejlett funkciói és a jobb fejlesztői élmény miatt. Íme a két megközelítés összehasonlítása:

Mikor válassza a Schema Stitchinget:

• Már létező GraphQL szolgáltatásai vannak, és gyorsan szeretné őket egyesíteni.
• Egyszerű föderációs megoldásra van szüksége, és nincsenek szüksége haladó funkciókra.
• Korlátozott erőforrásai vannak, és el szeretné kerülni az Apollo Föderáció beállításával járó többletterheket.

Mikor válassza az Apollo Föderációt:

• Nagy és komplex rendszert épít több csapattal és szolgáltatással.
• Szüksége van haladó funkciókra, mint a típus kiterjesztések, kulcs direktívák és az elosztott nyomkövetés.
• Robusztusabb és skálázhatóbb föderációs megoldást szeretne.
• Előnyben részesíti a deklaratívabb és automatizáltabb megközelítést a föderációhoz.

Valós példák és használati esetek

Íme néhány valós példa arra, hogyan használható a GraphQL Föderáció, beleértve a Schema Stitchinget is:

• E-kereskedelmi platform: Egy e-kereskedelmi platform használhatja a GraphQL Föderációt több szolgáltatás adatainak egyesítésére, mint például egy termékkatalógus-szolgáltatás, egy felhasználói szolgáltatás, egy rendelési szolgáltatás és egy fizetési szolgáltatás. Ez lehetővé teszi a kliensek számára, hogy könnyedén lekérjék az összes információt, amire szükségük van a termékadatok, felhasználói profilok, rendelési előzmények és fizetési információk megjelenítéséhez.
• Közösségi média platform: Egy közösségi média platform használhatná a GraphQL Föderációt a felhasználói profilokat, bejegyzéseket, hozzászólásokat és kedveléseket kezelő szolgáltatások adatainak egyesítésére. Ez lehetővé teszi a kliensek számára, hogy hatékonyan lekérjék az összes információt, amely egy felhasználó profiljának, bejegyzéseinek, valamint az ezekhez kapcsolódó hozzászólásoknak és kedveléseknek a megjelenítéséhez szükséges.
• Pénzügyi szolgáltatási alkalmazás: Egy pénzügyi szolgáltatási alkalmazás használhatja a GraphQL Föderációt a számlákat, tranzakciókat és befektetéseket kezelő szolgáltatások adatainak egyesítésére. Ez lehetővé teszi a kliensek számára, hogy könnyen lekérjék az összes információt, amire szükségük van a számlaegyenlegek, tranzakciós előzmények és befektetési portfóliók megjelenítéséhez.
• Tartalomkezelő rendszer (CMS): Egy CMS kihasználhatja a GraphQL Föderációt különböző forrásokból származó adatok, például cikkek, képek, videók és felhasználók által generált tartalmak integrálására. Ez egységes API-t tesz lehetővé az összes, egy adott témához vagy szerzőhöz kapcsolódó tartalom lekéréséhez.
• Egészségügyi alkalmazás: Integrálja a páciensek adatait különböző rendszerekből, mint például az elektronikus egészségügyi nyilvántartások (EHR), laboreredmények és időpont-egyeztetések. Ez az orvosoknak egyetlen hozzáférési pontot kínál az átfogó páciensinformációkhoz.

A Schema Stitching bevált gyakorlatai

A sikeres Schema Stitching implementáció érdekében kövesse az alábbi bevált gyakorlatokat:

• Gondosan tervezze meg a sémát: Mielőtt elkezdené a sémák összefűzését, gondosan tervezze meg az egységes séma szerkezetét. Ez magában foglalja a különböző sémák közötti típusok kapcsolatainak meghatározását, a típusok és mezők átnevezését a konfliktusok elkerülése érdekében, valamint az általános adathozzáférési minták figyelembevételét.
• Használjon következetes elnevezési konvenciókat: Alkalmazzon következetes elnevezési konvenciókat a típusokra, mezőkre és műveletekre minden szolgáltatásban. Ez segít elkerülni a konfliktusokat és megkönnyíti az egységes séma megértését.
• Dokumentálja a sémát: Dokumentálja alaposan az egységes sémát, beleértve a típusok, mezők és műveletek leírását. Ez megkönnyíti a fejlesztők számára a séma megértését és használatát.
• Figyelje a teljesítményt: Figyelje az átjáró és a távoli szolgáltatások teljesítményét a teljesítmény-szűk keresztmetszetek azonosítása és kezelése érdekében. Használjon olyan eszközöket, mint az elosztott nyomkövetés, a kérések több szolgáltatáson keresztüli követésére.
• Implementáljon biztonságot: Implementáljon megfelelő biztonsági intézkedéseket az átjáró és a távoli szolgáltatások jogosulatlan hozzáféréssel szembeni védelme érdekében. Ez magában foglalhatja a hitelesítési és engedélyezési mechanizmusok használatát, valamint a bemeneti validálást és a kimeneti kódolást.
• Verziózza a sémát: Ahogy fejleszti a sémáit, verziózza őket megfelelően, hogy a kliensek továbbra is használhassák a séma régebbi verzióit anélkül, hogy hibát okoznának. Ez segít elkerülni a törő változtatásokat és biztosítja a visszamenőleges kompatibilitást.
• Automatizálja a telepítést: Automatizálja az átjáró és a távoli szolgáltatások telepítését, hogy a változtatások gyorsan és megbízhatóan telepíthetők legyenek. Ez segít csökkenteni a hibák kockázatát és javítja a rendszer általános agilitását.

Következtetés

A GraphQL Föderáció a Schema Stitchinggel hatékony megközelítést kínál az egységes API-k létrehozására több szolgáltatásból egy mikroszolgáltatási architektúrában. A központi koncepciók, előnyök, korlátok és megvalósítási technikák megértésével kihasználhatja a Schema Stitchinget az adathozzáférés egyszerűsítésére, a skálázhatóság javítására és a karbantarthatóság növelésére. Bár az Apollo Föderáció egy fejlettebb megoldásként jelent meg, a Schema Stitching továbbra is életképes opció egyszerűbb forgatókönyvek esetén, vagy meglévő GraphQL szolgáltatások integrálásakor. Gondosan mérlegelje specifikus igényeit és követelményeit, hogy kiválassza a szervezetének legmegfelelőbb megközelítést.